/*
 * 文件名：screen.cpp
 * 功能描述：屏幕界面管理和用户交互
 */

#include <Arduino.h>
#include <screen.h>
#include <ui.h>
#include "screens.h"
#include "Display_ST7789.h"
#include "LVGL_Driver.h"
#include "bsp_ble.h"
#include <config.h>
#include "hall_id.h"
#include "power_management.h"
#include "button.h" // 添加button.h以访问need_screen_refresh

static bool settings_initialized = false;
// 当前页面标识（例如 "main_1", "move", "level", "settings"）
String page = "main";
// 控制 settings 子菜单中各项的调整状态：true 表示处于激活（绿）状态，false 表示未激活（红）状态
bool set_status = false;
bool set_beep_status = false;
bool set_voice_status = false;
bool set_mode_status = false;
bool set_sensitivity_status = false;

// 全局动画类型变量，用于设置页面切换时的动画效果
lv_scr_load_anim_t anim_type;
// 数据帧中发送的三个浮点数（此处用作占位数据）
int data55[6]; // 示例浮点数组
// 当前页面选中项的索引（用于 main_1、move、level 页面）
int current_page_idx = 0; // 当前页面索引（0=main_1, 1=main_2,...）
int prev_data1 = 0;
int settings_sel = 0;
int debug_sel = 0; // 存储 debug 页面的选中项索引
int speed_val = 0; // 存储 Speed 的调整值
int beep_val = 0;  // 存储 Beep 的调整值
int voice_val = 0; // 存储 Voice 的调整值
int level_val = 0; // 存储 level 的调整值
int Error_val = 0;
bool sd_status = 0;
int battery = 0;
bool ble_status = 0;
bool wifi_status = 0;
int mode_val = 2;
bool Cha_status = 1;
float hall_sensitivity_val = 2.75; // 存储霍尔传感器灵敏度值，默认对应滑块值5

// processMain1的上次编码器值，提升为全局变量
int prev_data1_main1 = -1;
// 1. 增加全局变量用于beep key状态
bool set_beep_key_status = false;

// ---------------------------------------------------------------------
// 辅助函数：更新列表中各项的外边框样式
// 参数：list       - 列表控件对象
//       selectedIndex - 选中项的索引
//       totalItems     - 列表总项数
//       outline_color  - 外边框颜色
// 功能：遍历列表，对指定索引项设置宽度及颜色，其余项清除外边框
inline static void update_list_outline(lv_obj_t *list, int selectedIndex, int totalItems, lv_color_t outline_color)
{
    // 遍历所有子控件，统一设置样式
    for (int i = 0; i < totalItems; i++)
    {
        lv_obj_t *item = lv_obj_get_child(list, i);
        if (item)
        {
            if (i == selectedIndex)
            {
                int border_w = (list == objects.mian_list || list == objects.mode_list) ? 5 : 3;
                int radius = (list == objects.mian_list || list == objects.mode_list) ? 10 : 5;
                lv_obj_set_style_outline_color(item, outline_color, 0);
                lv_obj_set_style_outline_width(item, border_w, 0);
                lv_obj_set_style_radius(item, radius, 0);
                lv_obj_set_style_shadow_width(item, 0, 0);
            }
            else
            {
                lv_obj_set_style_outline_width(item, 0, 0);
                lv_obj_set_style_outline_color(item, lv_color_hex(0x000000), 0);
            }
        }
    }
    // 整体刷新列表一次
    lv_obj_invalidate(list);
}

/* Function: update_index
 * Description: 根据 delta 更新索引值并进行边界检查，同时设置动画效果。
 */
int update_index(int current, int delta, int min_val, int max_val, lv_scr_load_anim_t &anim, bool forward)
{
    // 根据旋钮转动方向，正向或反向调整当前索引值，并对其进行边界检查
    int new_val = current + delta * (forward ? 1 : -1);
    if (new_val > max_val)
        new_val = max_val;
    if (new_val < min_val)
        new_val = min_val;
    // 根据旋钮转向设置动画效果，前进为左移动画，后退为右移动画
    anim = LV_SCR_LOAD_ANIM_NONE;
    return new_val;
}

void processMain1() // 主菜单
{
    const int MAX_PAGE_COUNT = 5; // 修改为5，与实际主菜单项数一致

    int d1 = encoderValue;
    if (d1 != prev_data1_main1)
    {
        bool forward = (d1 > prev_data1_main1);
        int new_idx = forward ? (current_page_idx + 1) % MAX_PAGE_COUNT
                              : (current_page_idx - 1 + MAX_PAGE_COUNT) % MAX_PAGE_COUNT;

        current_page_idx = new_idx;
        anim_type = forward ? LV_SCR_LOAD_ANIM_MOVE_LEFT : LV_SCR_LOAD_ANIM_MOVE_RIGHT;

        // 修改：先无动画滚动，再添加淡入动画，提升切换丝滑效果
        update_list_outline(objects.mian_list, current_page_idx, MAX_PAGE_COUNT, COLOR_GOLD);

        lv_obj_t *selected_item = lv_obj_get_child(objects.mian_list, current_page_idx);
        if (selected_item)
        {
            // 修改：先无动画滚动，再添加淡入动画，提升切换丝滑效果
            lv_obj_scroll_to_view_recursive(selected_item, LV_ANIM_OFF);
            // lv_obj_fade_in(selected_item, 50, 0);
        }

        prev_data1_main1 = d1;
    }
}

/* Function: processSettingsBasic
 * Description: 处理 settings 页面未激活状态下的子菜单项选择。
 */
void processSettingsBasic() // 未激活状态下的子菜单项选择
{
    static int visible_items[5] = {0, 1, 2, 3, 4}; // 当前可见的5个项目索引
    static bool scroll_started = false;            // 是否已开始滚动

    int d1 = encoderValue;
    if (d1 != prev_data1)
    {
        bool forward = (d1 > prev_data1);
        // 取模运算以确保索引在 0~3 范围内
        settings_sel = forward ? (settings_sel + 1) % 5 : (settings_sel - 1 + 5) % 5;

        // 处理滚动动画逻辑
        if (settings_sel == 3 && visible_items[3] == 2)
        {
            // 当选择到第4项(索引3)且第3项(索引2)可见时，滚动列表
            visible_items[0] = 1;
            visible_items[1] = 2;
            visible_items[2] = 3;
            visible_items[3] = 3;
            scroll_started = true;
        }
        else if (settings_sel == 0 && visible_items[0] == 1)
        {
            // 当选择到第1项(索引0)且不可见时，滚动回初始状态
            visible_items[0] = 0;
            visible_items[1] = 1;
            visible_items[2] = 2;
            visible_items[3] = 3;
            scroll_started = true;
        }

        // 更新选中项的外观
        update_list_outline(objects.settings_list, settings_sel, 5, COLOR_GOLD);

        // 找到选中项并滚动到视图
        lv_obj_t *selected_item = lv_obj_get_child(objects.settings_list, settings_sel);
        if (selected_item)
        {
            // 使用动画滚动到选中项
            lv_obj_scroll_to_view_recursive(selected_item, LV_ANIM_ON);
        }

        // 更新各项目的可见性状态
        for (int i = 0; i < 5; i++)
        {
            lv_obj_t *item = lv_obj_get_child(objects.settings_list, i);
            if (item)
            {
                bool should_be_visible = false;
                for (int j = 0; j < 5; j++)
                {
                    if (i == visible_items[j])
                    {
                        should_be_visible = true;
                        break;
                    }
                }

                if (should_be_visible)
                {
                    lv_obj_clear_flag(item, LV_OBJ_FLAG_HIDDEN);
                }
                else
                {
                    lv_obj_add_flag(item, LV_OBJ_FLAG_HIDDEN);
                }
            }
        }

        // 添加整体滚动动画
        if (scroll_started)
        {
            // 可以添加额外的动画效果
            anim_type = forward ? LV_SCR_LOAD_ANIM_MOVE_TOP : LV_SCR_LOAD_ANIM_MOVE_BOTTOM;
            scroll_started = false;
        }

        prev_data1 = d1;
    }
}

/* Function: processMode
 * Description: 处理 "move" 页面：更新 mode_list 的选中项及动画效果。
 */
void processMode()
{
    // 获取编码器值
    int d1 = encoderValue;
    // 如果编码器值改变且设置模式状态为false
    if (d1 != prev_data1 && set_mode_status == false)
    {
        // 判断编码器值是否增加
        bool forward = (d1 > prev_data1);
        // 根据编码器值增加或减少模式值
        mode_val = forward ? (mode_val + 1) % 4 : (mode_val - 1 + 4) % 4;
        // 更新模式值
        mode_g = mode_val;
        // 更新模式列表
        update_list_outline(objects.mode_list, mode_val, 4, COLOR_GOLD);
        // 更新上一个编码器值
        prev_data1 = d1;
    }
}

void processError()
{
    int d1 = encoderValue;                            // 获取编码器值
    if (d1 != prev_data1 && set_mode_status == false) // 如果编码器值发生变化且未处于设置模式
    {
        bool forward = (d1 > prev_data1); // 判断编码器值是否增加
        int scrollStep = 20;              // 每次滚动20像素

        if (forward)
        {
            Error_val += scrollStep;                                              // 累计正向滚动量（仅用于记录）
            lv_obj_scroll_by(objects.ste_error_info, 0, scrollStep, LV_ANIM_OFF); // 向下滚动
        }
        else
        {
            Error_val -= scrollStep;                                               // 累计反向滚动量
            lv_obj_scroll_by(objects.ste_error_info, 0, -scrollStep, LV_ANIM_OFF); // 向上滚动
        }
        prev_data1 = d1; // 更新编码器值
    }
}

/* Function: processLevel
 * Description: 处理 "level" 页面：更新 arc 控件数值并设置动画效果。
 */
void processLevel()
{
    // 获取编码器值
    int d1 = encoderValue;
    // 如果编码器值与上一次的值不同
    if (d1 != prev_data1)
    {
        // 判断编码器值是否大于上一次的值
        bool forward = (d1 > prev_data1);
        // 更新难度值
        level_val = update_index(level_val, 1, 1, 5, anim_type, forward);
        // 将难度值赋给全局变量
        // level_difficulty_g = level_val;
        // // 打印设置难度
        // Serial.print("设置难度为:");
        // Serial.println(level_difficulty_g);
        // 更新UI中的难度值
        lv_arc_set_value(objects.level_set, level_val);
        // 更新上一次的编码器值
        prev_data1 = d1;
    }
}

/* Function: processSettingsSubmenuToggle
 * Description: 处理 settings 子菜单开关切换，并互斥其它状态。
 */
void processSettingsSubmenuToggle()
{
    // 移除对 button_state 的检查，因为这个函数现在只在事件触发时被调用
    // 如果设置选择为4，则执行以下操作
    if (settings_sel == 4)
    { // Motion Speed 子菜单
        // 切换设置状态
        set_status = !set_status;
        // 更新设置列表的轮廓颜色
        update_list_outline(objects.settings_list, settings_sel, 5,
                            set_status ? COLOR_GREEN : COLOR_GOLD);
        // 将其他设置状态设置为false
        set_beep_status = false;
        set_voice_status = false;
        set_sensitivity_status = false;
        set_beep_key_status = false;
    }
    // 如果设置选择为3，则执行以下操作
    else if (settings_sel == 3)
    { // Beep Volume 子菜单
        // 切换蜂鸣器状态
        set_beep_status = !set_beep_status;
        // 更新设置列表的轮廓颜色
        update_list_outline(objects.settings_list, settings_sel, 5,
                            set_beep_status ? COLOR_GREEN : COLOR_GOLD);
        // 将其他设置状态设置为false
        set_status = false;
        set_voice_status = false;
        set_sensitivity_status = false;
        set_beep_key_status = false;
    }
    // 如果设置选择为2，则执行以下操作
    else if (settings_sel == 2)
    { // Voice Control 子菜单（原索引1，后移到0）
        // 切换语音控制状态
        set_voice_status = !set_voice_status;
        // 更新设置列表的轮廓颜色
        update_list_outline(objects.settings_list, settings_sel, 5,
                            set_voice_status ? COLOR_GREEN : COLOR_GOLD);
        // 将其他设置状态设置为false
        set_status = false;
        set_beep_status = false;
        set_sensitivity_status = false;
        set_beep_key_status = false;
    }
    // 如果设置选择为1，则执行以下操作
    else if (settings_sel == 1)
    { // Beep key 子菜单
        // 切换蜂鸣器按键状态
        set_beep_key_status = !set_beep_key_status;
        // 更新设置列表的轮廓颜色
        update_list_outline(objects.settings_list, settings_sel, 5,
                            set_beep_key_status ? COLOR_GREEN : COLOR_GOLD);
        // 将其他设置状态设置为false
        set_status = false;
        set_beep_status = false;
        set_voice_status = false;
        set_sensitivity_status = false;
        // 切换蜂鸣器开关
        if (set_beep_key_status)
        {
            beep_set(15); // 开启蜂鸣器
            lv_obj_add_state(objects.settings_beep_key, LV_STATE_CHECKED);
        }
        else
        {
            beep_set(0); // 关闭蜂鸣器
            lv_obj_clear_state(objects.settings_beep_key, LV_STATE_CHECKED);
        }
    }

    // 其他索引不处理
}

/* Function: update_voice_state
 * Description: 封装 Voice 状态更新，根据 enabled 参数添加或清除选中状态。
 */
void update_voice_state(bool enabled)
{
    // 你可以根据需要添加实际控制语音状态的代码
    if (enabled)
    {
        // 如果语音状态为启用，则添加选中状态
        lv_obj_add_state(objects.settings_voice, LV_STATE_CHECKED);
    }
    else
    {
        // 如果语音状态为禁用，则清除选中状态
        lv_obj_clear_state(objects.settings_voice, LV_STATE_CHECKED);
    }
}

/* Function: processSettingsAdjustments
 * Description: 处理 settings 页面激活状态下的数值调整（Speed、Beep、Voice）。
 */
void processSettingsAdjustments()
{
    int d1 = encoderValue;
    // Speed 数值调整：使用 slider 控件
    if (set_status == true && d1 != prev_data1)
    {
        bool forward = (d1 > prev_data1);
        speed_val = update_index(speed_val, 1, 1, 3, anim_type, forward);
        speed_set(speed_val);
        if (print_key)
        {
            Serial.print("速度调整为");
            Serial.println(speed_val);
        }
        lv_slider_set_value(objects.settings_speed, speed_val, LV_ANIM_OFF);
        lv_obj_refresh_ext_draw_size(objects.settings_speed); // 合并刷新调用
        prev_data1 = d1;
    }
    // Beep 数值调整
    if (set_beep_status == true && d1 != prev_data1)
    {
        bool forward = (d1 > prev_data1);
        beep_val = update_index(beep_val, 2, 0, 30, anim_type, forward);
        // beepLevel_g = beep_val;
        beep_set(beep_val);
        if (print_key)
        {
            Serial.print("Beep调整为");
            Serial.println(beepLevel_g);
        }
        lv_slider_set_value(objects.settings_beep, beep_val, LV_ANIM_OFF);
        lv_obj_refresh_ext_draw_size(objects.settings_beep); // 合并刷新调用
        prev_data1 = d1;
    }
    // Voice 调整：直接切换，取值为 0 或 1
    if (set_voice_status == true && d1 != prev_data1)
    {
        bool forward = (d1 > prev_data1);
        voice_val = forward ? 1 : 0;
        speaker_g = voice_val;
        String state = (speaker_g == 1) ? "on" : "off";
        speaker_set(state);
        anim_type = LV_SCR_LOAD_ANIM_NONE;
        update_voice_state(voice_val);
        if (print_key)
        {
            Serial.print("Voice调整为");
            Serial.println(voice_val);
        }
        prev_data1 = d1;
    }
    // Sensitivity 调整：使用 slider 控件
    if (set_sensitivity_status == true && d1 != prev_data1)
    {
        bool forward = (d1 > prev_data1);
        // 假设灵敏度值范围为 1-10
        int sensitivity_val = update_index(hall_sensitivity_val, 1, 1, 10, anim_type, forward);
        hall_sensitivity_val = sensitivity_val;

        // 将1-10的整数值映射到2.5-2.7之间的浮点值
        float mapped_value = 2.65 + (sensitivity_val - 1) * 0.02;

        // 确保值在2.5到2.7之间
        if (mapped_value < 2.65)
            mapped_value = 2.65;
        if (mapped_value > 2.85)
            mapped_value = 2.85;

        // 通过串口输出映射后的值
        if (print_key)
        {
            Serial.print("Hall Sensitivity: ");
            Serial.println(mapped_value, 3); // 显示3位小数
        }

        // 将映射后的值发送至STM32
        send_hall_sensitivity(mapped_value);

        // lv_slider_set_value(objects.hall_sensitivity, sensitivity_val, LV_ANIM_OFF);
        // lv_obj_refresh_ext_draw_size(objects.hall_sensitivity); // 刷新控件
        prev_data1 = d1;
    }
    // Beep key 开关调整（单击已切换，旋转时不处理）
    if (set_beep_key_status)
    {
        // 保持UI同步
        if (beepLevel_g > 0)
        {
            lv_obj_add_state(objects.settings_beep_key, LV_STATE_CHECKED);
        }
        else
        {
            lv_obj_clear_state(objects.settings_beep_key, LV_STATE_CHECKED);
        }
    }
}

// 封装通用的设置父对象函数
// 定义一个内联静态函数，用于设置对象的父对象，如果对象不为空
inline static void set_parent_if_not_null(lv_obj_t *obj, lv_obj_t *parent)
{
    // 如果对象不为空
    if (obj != nullptr)
    {
        // 设置对象的父对象
        lv_obj_set_parent(obj, parent);
    }
}

// 封装通用的显示或隐藏控件函数
// 定义一个内联静态函数，用于设置对象的可见性
inline static void set_visibility(lv_obj_t *obj, bool visible)
{
    // 如果对象不为空
    if (obj != nullptr)
    {
        // 如果可见性为真
        if (visible)
        {
            // 清除对象的隐藏标志
            lv_obj_clear_flag(obj, LV_OBJ_FLAG_HIDDEN);
        }
        // 否则
        else
        {
            // 添加对象的隐藏标志
            lv_obj_add_flag(obj, LV_OBJ_FLAG_HIDDEN);
        }
    }
}

/* Function: set_common_parents
 * Description: 将通用元素设置为指定屏幕的子对象，确保其始终可见。
 */
// 设置公共父对象
static void set_common_parents(lv_obj_t *screen)
{
    // 如果objects.battery_1不为空，则将其父对象设置为screen
    set_parent_if_not_null(objects.battery_1, screen);
    // 如果objects.battery_2不为空，则将其父对象设置为screen
    set_parent_if_not_null(objects.battery_2, screen);
    // 如果objects.ble不为空，则将其父对象设置为screen
    // set_parent_if_not_null(objects.ble, screen);//打开这个会重启
    // // 如果objects.wifi不为空，则将其父对象设置为screen
    // set_parent_if_not_null(objects.wifi, screen);//打开这个会重启
    // // 如果objects.warn不为空，则将其父对象设置为screen
    // set_parent_if_not_null(objects.warn, screen);//打开这个会重启
    // // 如果objects.battery_status不为空，则将其父对象设置为screen
    // set_parent_if_not_null(objects.battery_status, screen);//打开这个会重启
}

/* Function: switch_page
 * Description: 进行页面切换，更新页面标识、动画及通用元素父对象。
 */
static void switch_page(String newPage, lv_obj_t *newScreen)
{
    // 切换页面时首先更新全局页面标识，然后加载新屏幕（无动画）并重新设置公共控件的父对象
    page = newPage;                                      // 更新页面标识
    lv_scr_load_anim(newScreen, anim_type, 0, 0, false); // 加载新屏幕
    // set_common_parents(newScreen);                       // 设置公共父对象（打开后会导致重启）
    button_state = 1;                                    // 标记数据已经更新
    if (newPage == "main")
    {
        // 如果新页面是主页面，则更新设置列表的轮廓
        update_list_outline(objects.settings_list, -1, 5, COLOR_GOLD);
    }
}

void reset_settings()
{
    // 重置设置状态
    set_status = false;
    set_beep_status = false;
    set_voice_status = false;
    set_sensitivity_status = false;

    // 重置选中项索引
    settings_sel = 0;
    debug_sel = 0;
}

void add_text(String text[], bool clear_first)
{
    // 如果需要先清空文本框
    if (clear_first)
    {
        lv_textarea_set_text(objects.ste_error_info, "");
    }

    // 自动计算文本数组的实际长度（遇到空字符串停止）
    int len = 0;
    while (text[len] != "")
    {
        len++;
    }

    // 逐个添加文本到文本框
    for (int i = 0; i < len; i++)
    {
        lv_textarea_add_text(objects.ste_error_info, text[i].c_str());
    }
}
String my_texts[] = {
    "" // 必须以此结尾（用于自动计算长度）
};

// 更新模式
void update_mode(int val)
{
    // 更新模式列表的轮廓
    update_list_outline(objects.mode_list, val, 4, COLOR_GOLD);
}

// 更新等级
void update_level(int val)
{
    // 设置等级
    lv_arc_set_value(objects.level_set, val);
}

// 更新速度
void update_speed(int val)
{
    // 设置滑块值为val，不使用动画
    lv_slider_set_value(objects.settings_speed, speed_val, LV_ANIM_OFF);
}

// 更新蜂鸣器音量
void update_beep(int val)
{
    // 设置滑块值为蜂鸣器音量，关闭动画
    lv_slider_set_value(objects.settings_beep, beep_val, LV_ANIM_OFF);
}

void update_sensitivity(int val)
{
    // 设置滑块对象的值，不使用动画效果
    // lv_slider_set_value(objects.hall_sensitivity, val, LV_ANIM_OFF);
}

// 切换到子页面
void switch_to_subpage()
{
    // 根据当前页面的索引，切换到对应的子页面
    switch (current_page_idx)
    {
    case 0:
        // 切换到模式页面
        switch_page("mode", objects.main_2);
        // 更新模式
        update_mode(mode_g);
        lv_obj_invalidate(objects.main_2); // 强制重绘

        break;
    case 1:
        switch_page("level", objects.main_4);
        update_level(level_val);
        lv_obj_invalidate(objects.main_4); // 强制重绘
        break;
    case 2:
        switch_page("settings", objects.main_5);
        update_speed(speed_val);
        update_beep(beep_val);
        update_voice_state(voice_val);
        update_sensitivity(hall_sensitivity_val);
        lv_obj_invalidate(objects.main_5); // 强制重绘
        break;
    case 3:
        switch_page("info", objects.main_6);
        lv_obj_invalidate(objects.main_6); // 强制重绘
        break;
    case 4:
        switch_page("error_info", objects.main_7);
        lv_obj_invalidate(objects.main_7); // 强制重绘
        break;

    default:
        break;
    }
    settings_initialized = false;
}

// 初始化 settings 页面的控件
void initialize_settings_page()
{
    // 初始化选中项索引
    settings_sel = 0;

    // 初始化控件值
    lv_slider_set_value(objects.settings_speed, speed_val, LV_ANIM_OFF);
    lv_obj_invalidate(objects.settings_speed);
    lv_slider_set_value(objects.settings_beep, beep_val, LV_ANIM_OFF);
    lv_obj_invalidate(objects.settings_beep);
    update_voice_state(voice_val);
    // lv_slider_set_value(objects.hall_sensitivity, hall_sensitivity_val, LV_ANIM_OFF);
    // lv_obj_invalidate(objects.hall_sensitivity);
    set_beep_key_status = false;
    // 同步蜂鸣器开关状态
    if (beepLevel_g > 0)
    {
        lv_obj_add_state(objects.settings_beep_key, LV_STATE_CHECKED);
    }
    else
    {
        lv_obj_clear_state(objects.settings_beep_key, LV_STATE_CHECKED);
    }

    // 确保标签文本显示正确
    // lv_label_set_text(objects.sensitivity, "Sensitivity");

    // 初始化各项目的可见性状态 - 默认显示前4项(索引0-3)
    for (int i = 0; i < 5; i++)
    {
        lv_obj_t *item = lv_obj_get_child(objects.settings_list, i);
        if (item)
        {
            lv_obj_clear_flag(item, LV_OBJ_FLAG_HIDDEN);
        }
    }

    // 重置选中状态
    update_list_outline(objects.settings_list, settings_sel, 5, COLOR_GOLD);

    settings_initialized = true;
}

// 新增：事件驱动接口
// 当编码器单机事件发生时
void on_encoder_click_event()
{
    // 如果当前页面是主页面
    if (page == "main")
    {
        // 切换到子页面
        switch_to_subpage();
    }
    // 如果当前页面是设置页面
    else if (page == "settings")
    {
        // 处理设置子菜单切换
        processSettingsSubmenuToggle();
    }
    // 如果当前页面是level页面
    else if (page == "level")
    {
        // 点击时保存当前难度设置
        level_difficulty_g = level_val;
        save_level();
        if (print_key)
        {
            Serial.print("保存难度设置: ");
            Serial.println(level_difficulty_g); // 此处重启了一次
        }
        // 使用封装好的函数切换回主页面，避免直接操作UI元素
        // switch_page("main", objects.main_3);
        // 需要重置设置状态
        reset_settings();
    }
}
// 当编码器双击事件发生时
void on_encoder_double_click_event()
{
    // 如果当前页面不是"main"，则打印当前页面索引，并切换到"main"页面，并重置设置
    if (page != "main")
    {
        if (print_key)
        {
            Serial.println(current_page_idx);
        }
        switch_page("main", objects.main_3);
        reset_settings();
    }
    else
    {
        if (print_key)
        {
            Serial.println("当前页面是main");
        }
    }
}

static void processFrame()
{
    if (page == "main")
    {
        processMain1();
    }
    else if (page == "settings")
    {
        if (!settings_initialized)
        {
            initialize_settings_page();
        }
        if (!set_status && !set_beep_status && !set_voice_status && !set_sensitivity_status)
            processSettingsBasic();
        else
            processSettingsAdjustments();
    }
    else if (page == "mode")
    {
        processMode();
    }
    else if (page == "level")
    {
        processLevel();
    }
    else if (page == "info")
    {
        // 添加静态缓存变量
        static String prev_wifi_name = "";
        static String prev_ip = "";
        static String prev_fireware = "";
        static String prev_sn = "";

        if (wifi_name_g != prev_wifi_name)
        {
            lv_label_set_text(objects.wifi_name, wifi_name_g.c_str());
            prev_wifi_name = wifi_name_g;
        }
        if (ip_g != prev_ip)
        {
            lv_label_set_text(objects.ip_set, ip_g.c_str());
            prev_ip = ip_g;
        }
        if (firmware_version_g != prev_fireware)
        {
            lv_label_set_text(objects.fireware_set, firmware_version_g.c_str());
            prev_fireware = firmware_version_g;
        }
        if (sn_g != prev_sn)
        {
            lv_label_set_text(objects.sn_set, sn_g.c_str());
            prev_sn = sn_g;
        }
    }
    else if (page == "error_info")
    {
        // 新增：仅当 my_texts 有变化时更新
        static String lastMyTexts = "";
        String currentMyTexts = "";
        for (int i = 0; my_texts[i] != ""; i++)
        {
            currentMyTexts += my_texts[i];
        }
        if (currentMyTexts != lastMyTexts)
        {
            add_text(my_texts, true); // 添加文本
            lastMyTexts = currentMyTexts;
        }
        processError();
    }
}

void Task1(void *pvParameters)
{
    while (1)
    {
        // Serial.print("扫描任务栈剩余空间：");
        // Serial.println(uxTaskGetStackHighWaterMark(NULL));
        // 同时更新 BLE、WiFi、电池及充电状态
        // set_visibility(objects.ble, 0);
        Error_val = 0;
        ble_status = deviceConnected_g;
        wifi_status = wifi_status_g;
        battery = batteryLevel_g;
        Cha_status = Charging_status;
        mode_val = mode_g;
        speed_val = get_current_speed();
        beep_val = beepLevel_g;
        voice_val = speaker_g;
        // 只在非level页面时同步level_val，避免覆盖用户设置
        if (page != "level")
        {
            level_val = level_difficulty_g;
        }

        set_visibility(objects.ble, ble_status);            // BLE 状态更新
        set_visibility(objects.wifi, wifi_status);          // WiFi 状态更新
        set_visibility(objects.warn, Error_val);            // 错误警告显示
        set_visibility(objects.battery_status, Cha_status); // 充电状态更新

        // 电池电量更新（显示+颜色）
        if (battery >= 0)
        {
            lv_slider_set_value(objects.battery_level, battery, LV_ANIM_ON); // 设置电池电量值

            lv_color_t color;
            if (battery < 10)
            {
                color = COLOR_RED;
            }
            else if (battery < 30)
            {
                color = COLOR_ORANGE;
            }
            else
            {
                color = COLOR_GREEN;
            }
            lv_obj_set_style_bg_color(objects.battery_level, color, LV_PART_INDICATOR); // 设置电池电量颜色
        }

        // 根据接收数据决定调用对应页面的处理逻辑
        processFrame();

        // // 检查是否需要立即刷新屏幕（编码器旋转后）
        // if (need_screen_refresh)
        // {
        //     need_screen_refresh = false; // 清除标志
        //     // 立即处理一次屏幕刷新，确保编码器旋转效果及时显示
        //     processFrame();
        // }

        // 每次循环延时，防止任务占用过多 CPU 资源
        vTaskDelay(10 / portTICK_PERIOD_MS); // 调整延时，以优化刷新频率
    }
}

void screen_init()
{
    LCD_Init();  // 初始化 LCD 显示屏
    Lvgl_Init(); // 初始化 LVGL 图形库，用于图形界面绘制
    ui_init();   // 初始化各 UI 组件及控件
    lv_scr_load_anim(objects.main_3, LV_SCR_LOAD_ANIM_NONE, 0, 2000, false);
    // 配置公共控件（如电池、蓝牙、WiFi 图标等），设置其显示状态和父对象
    set_visibility(objects.battery_1, true);
    set_visibility(objects.battery_2, true);
    set_visibility(objects.battery_status, true);
    set_parent_if_not_null(objects.battery_1, objects.main_3);
    set_parent_if_not_null(objects.battery_2, objects.main_3);
    set_parent_if_not_null(objects.ble, objects.main_3);
    set_parent_if_not_null(objects.wifi, objects.main_3);
    set_parent_if_not_null(objects.warn, objects.main_3);
    set_parent_if_not_null(objects.battery_status, objects.main_3);
    lv_textarea_set_text(objects.ste_error_info, ""); // 清空内容
    lv_label_set_text(objects.ip_set, "");

    lv_label_set_text(objects.wifi_name, "");
    xTaskCreatePinnedToCore(
        Task1,
        "SerialTask",
        2048,
        NULL,
        1,
        NULL,
        0);
}
